# day5作业：
# 1、写函数,将传入的列表或元祖对象的奇数位索引对应的元素
def ele(element):
    list1 = []
    for i in range(len(element)):
        if i%2!=0:
            list1.append(element[i])
    return list1

# 2、写函数,判断用户传入的对象(string,list,tuple)长度是否大于5
def islength(ele):
    if type(ele) == str:
        print(f"是字符串")
        if len(ele) > 5:
            print(f"长度大于5")
        else:
            print("长度没有大于5")
    elif type(ele) == list:
        print("是列表")
        if len(ele) > 5:
            print("长度大于5")
        else:
            print("长度没有大于5")
    elif type(ele) == tuple:
        print("是元组对象")
        if len(ele) > 5:
            print("长度大于5")
        else:
            print("长度没有大于5")
# 3、写函数,计算传入的string中,数字,字母,空格以及其它内容的个数,并返回结果
def ss(string):
    # 定义收集器：数字
    num = 0
    # 定义收集器：字母
    zimu = 0
    # 空格
    space = 0
    # 其他
    other = 0
    # 循环遍历字符串
    for i in string:
        # 判断是不是字母
        if (i >= 'a' and i <= 'z') or (i >= 'A' and i <= 'Z'):
            zimu += 1
        # 判断是不是数字
        elif i in "0123456789":
            num += 1
        # 判断是不是空格
        elif i == ' ':
            space += 1
        # 判断是不是其他内容
        else:
            other += 1
    print(f"计算传入的string中,数字：{num},字母：{zimu},空格：{space}，以及其它内容：{other}")

# 4、写函数,接收两个数字参数,返回较大的那个数字
def max_num(a:int,b:int)->int:
    if a> b:
        return a
    elif a < b:
        return b
# 5、编写一个函数cacluate, 可以接收任意多个数,返回的是一个元组.
def cacluate(*args):
    return args

# 6、编写一个函数, 接收字符串参数, 返回一个元组,元组的第一个值为大写字母的个数, 第二个值为小写字母个数.
def ss1(str_obj)->tuple:
    d = 0
    x = 0
    for i in str_obj:
        if i>='a' and i<='z':
            x+=1
        elif i>='A' and i<='Z':
            d+=1
    return (d,x)
# 7、编写函数, 接收一个列表(包含30个1~100之间的随机整形数)和一个整形数k, 返回一个新列表.
# 函数需求:
# 将列表下标k之前对应(不包含k)的元素逆序;
# 将下标k及之后的元素逆序;
def newlist(list1:list,k:int)->list:
    list1_1 = list1[:k][::-1]
    list1_2 = list1[k:][::-1]
    list3 =  list1_1+list1_2
    return list3

# 8、编写函数，从键盘输入参数x和n，计算并显示形如x+xx +xxx + xxxx + xxxxx+xxx…xxx+ 的表达式前n项的值
def nSum():
    # x*10+x本身，n是控制加几次
    x = int(input("请输入x："))
    n = int(input("请输入n："))
    a = x       # 定死个位数
    sum = 0     # 收集器
    while n:        # 5
        n -= 1
        sum+=x
        x=x*10+a
    return f"累加的和是：{sum}"


print(nSum())


# 9、写函数,函数接收的4个参数分别是:姓名,性别(默认为男),年龄,地址
def info1(name,age,address,sex='男'):
    print(f"姓名是：{name}，年龄是：{age}，地址是：{address}，性别是：{sex}")
# 10、写函数,接收n个数字,返回这些数字的和(动态传参)
def sum1(*n):
    sum = 0
    for i in n:
        sum=sum+i
    return sum

# 11、在实参中传入多个可迭代对象(要有string,list,tuple,set,dict),将每个对象的每个元素都加到args或kwargs里
def ss3(*args,**kwargs):
    print(args)
    print(kwargs)
ss3(1,2,3,4,name='张三')
# 12、写函数,把传过来的列表中的每一个元素都用"_"拼接,并返回
def list_(list1:list)->str:
    str1 = ""
    for i in list1:
        str1 +=str(i) + "_"
    return str1

# 13、写函数,传入一个数字,返回这个数的阶乘。示例：1x2x3....
def jiecheng(n):
    num = 1
    for i in n:
        num*=i
    return f"这个数的阶乘是：{num}"

# 14、写函数,返回一个扑克牌列表,里面有52项,每一项都是一个tuple
def puke():
    puke_list = []
    huase = ['梅花','红桃','黑桃','红片']
    # 2~10
    for i in huase:
        for j in range(2,11):
            puke_list.append((i,j))
    # j~A
    jqka = [(j,i) for i in ['J','Q','K','A'] for j in huase]
    puke_list.extend(jqka)
    return puke_list
# print(len(puke()))
# 15、编写函数，求1+2+3+…N的和
def n_sum(n):
    sum = 0
    for i in range(n+1):
        sum+=i
    return "求1+2+3+…N的和：%s"%sum

# 16、编写一个函数，求多个数中的最大值
def maxNum(*args):
    max_num = args[0]
    for i in args:
        if i > max_num:
            max_num = i
    return f"求多个数中的最大值：{max_num}"

# print(maxNum(11, 22, 55555,33, 444))

# 17、编写一个函数，提取指定字符串中所有的字母，然后拼接在一起产生一个新的字符串
def newStr(strobj:str)->str:
    result = ""
    for i in strobj:
        if (i >='a' and i<='z') or (i >='A' and i<='Z'):
            result+=i
    return "提取指定字符串中所有的字母，然后拼接在一起产生一个新的字符串：%s"%result

# 18、写一个函数，求多个数的平均值
def avgNum(*args):
    return sum(args) / len(args)
# print(avgNum(11, 22, 33, 44, 55))

# 19、写一个自己的len函数，统计指定序列中元素的个数
def length(xu):
    n = 0
    for i in xu:
        n+=1
    return f"元素序列的个数是：{n}"

# 20、找出传入的列表或元组的奇数位对应的元素，并返回一个新的列表
def newList1(ele1):
    list1 = []
    for i in range(len(ele1)):
        if i % 2 != 0:
            list1.append(ele1[i])
    return list1

# 21、水仙花数：个位、十位、百位的立方加在一起等于数的本身
def shuixian():
    for i in range(100,1000):
        if int(str(i)[0])**3 +  int(str(i)[1])**3 + int(str(i)[2])**3 == i:
            print(i)

# 22、 定义函数，有一个形参，传入的是列表，数组大小不超过 100个，
# 数组中的每个元素值不允许超过 100，但是可以等于100，
# 如果列表大小超过了100个截取到第100个为止，要求返回的列表格式：
# 删除所有重复元素，使得每个元素只出现一次
# 按照数字的大小，由高到低排序返回
def list2(list_obj:list)->list:
    if len(list_obj) > 100:
        list_obj = list_obj[:100]
        list_obj = list(set(list_obj))
        list_obj.sort(reverse=True)
        return list_obj
    else:
        list_obj = list(set(list_obj))
        list_obj.sort(reverse=True)
        return list_obj

# 23、定义函数 getLength，打印用户传入的容器类型和数据长度
def getLength(ele):
    if isinstance(ele,str):
        print(f"是字符串类型，长度位：{len(ele)}")
    elif isinstance(ele,list):
        print(f"是列表类型，长度为：{len(ele)}")
    elif isinstance(ele,tuple):
        print(f"是元组类型，长度为：{len(ele)}")
    elif isinstance(ele,dict):
        print(f"是字典类型，长度为：{len(ele)}")
    elif isinstance(ele,set):
        print(f"是集合类型，长度为：{len(ele)}")
    elif isinstance(ele,int):
        print(f"是整数类型，长度为：{len(str(ele))}")
# 24、定义函数 generateNum( )
def generateNum():
    pass
# 25、定义函数 moreThan(num)，判断输入的数字是否大于1500
def moreThan(num):
    if num >1500:
        print("大于1500")
    elif num < 1500:
        print("小于1500")
    elif num == 1500:
        print("等于1500")
# 26、定义函数，有两个形参，第一个形参到第二个形参的范围，所有平方数之和
def avgSum(a,b):
    sum = 0
    for i in range(a,b+1):
        sum += i**2
    return sum
# 27、写函数，检查传入字典的每一个value长度，如果大于2，那么仅保留前两个长度的内容， 并将新内容返回给调用者
def length2(dict1):
    for key,value in dict1.items():
        if isinstance(value,int):
            if len(str(value)) > 2:
                dict1[key] = int(str(value)[:2])
        else:
            dict1[key] = value[:2]
    return dict1
# dict1 = {"name":"suki","age":112}
# print(length2(dict1))

#  28、写函数，判断用户传入的对象（字符串、列表、元组）的元素是否为空
def isNone(eles):
    if eles:        # 判断的布尔值，如果是真的，就不是空的
        print("不为空")
    else:       # 反之，是空的
        print("为空")

# isNone("")
# isNone(" ")


# 29、编写自定义函数，完成一个简单的减法运算函数
def jian(a,b):
    return a-b
# 30、编写自定义函数，可以输出自己的名字即可。
def names():
    name = input("输入你的名字：")
    print(name)
# 31、编写自定义函数：剪刀石头布
# 游戏开始，初始状态下用户和电脑都有 100 分，赢一局+10 分，输一局-10 分。
# 当用户为 0 分时，游戏结束，提示游戏结束，比赛输了
# 当用户为 200 分时，游戏结束，提示游戏结束，赢得比赛、每轮比赛都输出当前的分数
# 1 代表剪刀 2 代表石头 3 代表布
def playGame():
    from random import randint
    user = 100
    comp = 100
    while True:
        if user == 0 and comp == 200:
            print("游戏结束！")
            print("本局游戏：电脑胜利！")
            break
        elif user == 200 and comp ==0:
            print("游戏结束！")
            print("本局游戏：玩家胜！")
            break
        # 玩家出拳
        r = int(input("1 代表剪刀 2 代表石头 3 代表布，请出拳："))
        # 电脑出拳
        d = randint(1,3)
        if r == 1 and d == 1:
            print("平局！")
            print("你还有：%s分数"%user)
            print("电脑还有：%s分数"%comp)
        elif r == 1 and d==2:
            print("你输了！")
            user-=10
            comp+=10
            print("你还有：%s分数" % user)
            print("电脑还有：%s分数" % comp)
        elif r== 1 and d==3:
            print("你赢了！")
            user+=10
            comp-=10
            print("你还有：%s分数" % user)
            print("电脑还有：%s分数" % comp)
        elif r ==2 and d==1:
            print("你赢了！")
            user += 10
            comp -= 10
            print("你还有：%s分数" % user)
            print("电脑还有：%s分数" % comp)
        elif r==2 and d==2:
            print("平局！")
            print("你还有：%s分数" % user)
            print("电脑还有：%s分数" % comp)
        elif r==2 and d==3:
            print("你输了！")
            user -= 10
            comp += 10
            print("你还有：%s分数" % user)
            print("电脑还有：%s分数" % comp)
        elif r ==3 and d==1:
            print("你输了！")
            user -= 10
            comp += 10
            print("你还有：%s分数" % user)
            print("电脑还有：%s分数" % comp)
        elif r==3 and d==2:
            print("你赢了！")
            user += 10
            comp -= 10
            print("你还有：%s分数" % user)
            print("电脑还有：%s分数" % comp)
        elif r==3 and d==3:
            print("平局！")
            print("你还有：%s分数" % user)
            print("电脑还有：%s分数" % comp)

# 32、编写一个函数，接受一个字符串作为参数，并返回该字符串的逆序字符串
def strs(str1:str)->str:
    return str1[::-1]

# 33、编写一个函数，接受一个数字列表作为参数，并返回其中所有偶数的列表
def numList(list1:list)->list:
    list2 = []
    for i in list1:
        if i%2==0:
            list2.append(i)
    return list2
# 34、编写一个函数，接受一个字符串列表作为参数，并返回其中最长的字符串。
def strList(strList1:list)->str:
    max_str = strList1[0]
    for i in strList1:
        if len(i) > len(max_str):
            max_str = i
    return max_str

# 35、编写一个函数，接受一个数字列表作为参数，并返回其中所有数字的平方的总和
def numlist3(nlist:list)->str:
    sum = 0
    for i in nlist:
        sum += i**2
    return f"接受一个数字列表作为参数，并返回其中所有数字的平方的总和：{sum}"

# 36、编写一个函数，接受一个字符串作为参数，并返回其中所有单词的首字母的大写形式
def da_str(str_obj:str):
    result = ""
    for i in str_obj:
        result += i.capitalize()
    return result

# 37、编写一个函数，接受两个列表作为参数，并返回两个列表的交集
# 举例：
# list1 = [100,200,300,454]
# list2 = [454,789,125,46]
# 返回：[454]
def jiaoList(a:list,b:list)->list:
    result = []
    for i in range(len(a)):
        if b[i] == a[i]:
            result.append(b[i])
    return result

#  38、定义一个学生注册函数enroll()，打印学生姓名，性别，年龄，城市
def enroll(name,sex,age,address):
    print(f"姓名是：{name}，性别是：{sex}，年龄是：{age}，城市是：{address}")

